// 蜂窝蜜造平台生成代码，如手工更改，请添加到 .beeignore 忽略生成

package com.fowo.api.model.receivable;

import com.fowo.api.common.annotaion.DataObjectType;
import com.fowo.api.common.meta.MetaDataObject;
import com.fowo.api.common.meta.MetaDataObjects;
import com.fowo.api.common.model.PageSearch;
import com.fowo.api.common.mybatis.helper.PageSearchHelper;
import com.fowo.api.common.util.ListUtils;
import com.fowo.api.entity.Receivable;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import lombok.Getter;
import lombok.Setter;
import org.springframework.format.annotation.DateTimeFormat;

@DataObjectType(Receivable.class)
@Setter
@Getter
public class ReceivableSearchParamPo extends PageSearch {

  private static MetaDataObject metaDataObject;

  @Override
  public void applySqlSegments() {
    if (metaDataObject == null) {
      metaDataObject =
        ListUtils.find(
          MetaDataObjects.getObjects(),
          o -> "Receivable".equals(o.getName())
        );
    }
    PageSearchHelper.fillSqlSegments(this, metaDataObject);
  }

  @Override
  public void initFinal() {
    super.initFinal();
    applySqlSegments();
  }

  /**
   * 获取关联字段的查询表别名信息
   */
  @Override
  public Map<String, String> getJoinFieldTableAliasMap() {
    Map<String, String> map = new HashMap<>();
    map.put("customer", "s");
    map.put("closeOrg", "sd");
    map.put("receiptOrg", "sd2");
    map.put("orderer", "s2");
    map.put("consignee", "s3");
    map.put("payer", "s4");
    map.put("preparedBy", "su");
    map.put("verifier", "su2");
    return map;
  }

  @Override
  public Map<String, OptionalJoinField> getOptionalJoinFields() {
    Map<String, OptionalJoinField> map = new HashMap<>();

    return map;
  }

  /**
   * 编号
   */
  private Long id;

  /**
   * 最小编号
   */
  private Long idMin;

  /**
   * 最大编号
   */
  private Long idMax;

  /**
   * 编号 比较(eq)
   */
  private Long idEq;
  /**
   * 编号 比较(neq)
   */
  private Long idNeq;
  /**
   * 编号 比较(gt)
   */
  private Long idGt;
  /**
   * 编号 比较(gte)
   */
  private Long idGte;
  /**
   * 编号 比较(lt)
   */
  private Long idLt;
  /**
   * 编号 比较(lte)
   */
  private Long idLte;
  /**
   * 编号 比较(contains)
   */
  private Long idContains;
  /**
   * 编号 比较(notcontains)
   */
  private Long idNotcontains;
  /**
   * 编号 比较(startswith)
   */
  private Long idStartswith;
  /**
   * 编号 比较(endswith)
   */
  private Long idEndswith;
  /**
   * 编号 比较(isnull)
   */
  private Boolean idIsnull;
  /**
   * 编号 比较(isnotnull)
   */
  private Boolean idIsnotnull;

  /**
   * 单据编号(模糊搜索)
   */
  private String payCode;

  /**
   * 单据编号 比较(eq)
   */
  private String payCodeEq;
  /**
   * 单据编号 比较(neq)
   */
  private String payCodeNeq;
  /**
   * 单据编号 比较(gt)
   */
  private String payCodeGt;
  /**
   * 单据编号 比较(gte)
   */
  private String payCodeGte;
  /**
   * 单据编号 比较(lt)
   */
  private String payCodeLt;
  /**
   * 单据编号 比较(lte)
   */
  private String payCodeLte;
  /**
   * 单据编号 比较(contains)
   */
  private String payCodeContains;
  /**
   * 单据编号 比较(notcontains)
   */
  private String payCodeNotcontains;
  /**
   * 单据编号 比较(startswith)
   */
  private String payCodeStartswith;
  /**
   * 单据编号 比较(endswith)
   */
  private String payCodeEndswith;
  /**
   * 单据编号 比较(isnull)
   */
  private Boolean payCodeIsnull;
  /**
   * 单据编号 比较(isnotnull)
   */
  private Boolean payCodeIsnotnull;

  /**
   * 单据编号(精确搜索)
   */
  private List<String> payCodeInList;

  /**
   * 单据类型
   */
  private String type;

  /**
   * 单据类型 比较(eq)
   */
  private String typeEq;
  /**
   * 单据类型 比较(neq)
   */
  private String typeNeq;
  /**
   * 单据类型 比较(gt)
   */
  private String typeGt;
  /**
   * 单据类型 比较(gte)
   */
  private String typeGte;
  /**
   * 单据类型 比较(lt)
   */
  private String typeLt;
  /**
   * 单据类型 比较(lte)
   */
  private String typeLte;
  /**
   * 单据类型 比较(contains)
   */
  private String typeContains;
  /**
   * 单据类型 比较(notcontains)
   */
  private String typeNotcontains;
  /**
   * 单据类型 比较(startswith)
   */
  private String typeStartswith;
  /**
   * 单据类型 比较(endswith)
   */
  private String typeEndswith;
  /**
   * 单据类型 比较(isnull)
   */
  private Boolean typeIsnull;
  /**
   * 单据类型 比较(isnotnull)
   */
  private Boolean typeIsnotnull;

  /**
   * 单据类型(精确搜索)
   */
  private List<String> typeInList;

  /**
   * 最早创建时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date createTimeStart;

  /**
   * 最晚创建时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date createTimeEnd;

  /**
   * 创建时间 比较(eq)
   */
  private Date createTimeEq;
  /**
   * 创建时间 比较(neq)
   */
  private Date createTimeNeq;
  /**
   * 创建时间 比较(gt)
   */
  private Date createTimeGt;
  /**
   * 创建时间 比较(gte)
   */
  private Date createTimeGte;
  /**
   * 创建时间 比较(lt)
   */
  private Date createTimeLt;
  /**
   * 创建时间 比较(lte)
   */
  private Date createTimeLte;
  /**
   * 创建时间 比较(contains)
   */
  private Date createTimeContains;
  /**
   * 创建时间 比较(notcontains)
   */
  private Date createTimeNotcontains;
  /**
   * 创建时间 比较(startswith)
   */
  private Date createTimeStartswith;
  /**
   * 创建时间 比较(endswith)
   */
  private Date createTimeEndswith;
  /**
   * 创建时间 比较(isnull)
   */
  private Boolean createTimeIsnull;
  /**
   * 创建时间 比较(isnotnull)
   */
  private Boolean createTimeIsnotnull;

  /**
   * 创建人
   */
  private Long createUser;

  /**
   * 最小创建人
   */
  private Long createUserMin;

  /**
   * 最大创建人
   */
  private Long createUserMax;

  /**
   * 创建人 比较(eq)
   */
  private Long createUserEq;
  /**
   * 创建人 比较(neq)
   */
  private Long createUserNeq;
  /**
   * 创建人 比较(gt)
   */
  private Long createUserGt;
  /**
   * 创建人 比较(gte)
   */
  private Long createUserGte;
  /**
   * 创建人 比较(lt)
   */
  private Long createUserLt;
  /**
   * 创建人 比较(lte)
   */
  private Long createUserLte;
  /**
   * 创建人 比较(contains)
   */
  private Long createUserContains;
  /**
   * 创建人 比较(notcontains)
   */
  private Long createUserNotcontains;
  /**
   * 创建人 比较(startswith)
   */
  private Long createUserStartswith;
  /**
   * 创建人 比较(endswith)
   */
  private Long createUserEndswith;
  /**
   * 创建人 比较(isnull)
   */
  private Boolean createUserIsnull;
  /**
   * 创建人 比较(isnotnull)
   */
  private Boolean createUserIsnotnull;

  /**
   * 最早更新时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date lastUpdateTimeStart;

  /**
   * 最晚更新时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date lastUpdateTimeEnd;

  /**
   * 更新时间 比较(eq)
   */
  private Date lastUpdateTimeEq;
  /**
   * 更新时间 比较(neq)
   */
  private Date lastUpdateTimeNeq;
  /**
   * 更新时间 比较(gt)
   */
  private Date lastUpdateTimeGt;
  /**
   * 更新时间 比较(gte)
   */
  private Date lastUpdateTimeGte;
  /**
   * 更新时间 比较(lt)
   */
  private Date lastUpdateTimeLt;
  /**
   * 更新时间 比较(lte)
   */
  private Date lastUpdateTimeLte;
  /**
   * 更新时间 比较(contains)
   */
  private Date lastUpdateTimeContains;
  /**
   * 更新时间 比较(notcontains)
   */
  private Date lastUpdateTimeNotcontains;
  /**
   * 更新时间 比较(startswith)
   */
  private Date lastUpdateTimeStartswith;
  /**
   * 更新时间 比较(endswith)
   */
  private Date lastUpdateTimeEndswith;
  /**
   * 更新时间 比较(isnull)
   */
  private Boolean lastUpdateTimeIsnull;
  /**
   * 更新时间 比较(isnotnull)
   */
  private Boolean lastUpdateTimeIsnotnull;

  /**
   * 更新人
   */
  private Long lastUpdateUser;

  /**
   * 最小更新人
   */
  private Long lastUpdateUserMin;

  /**
   * 最大更新人
   */
  private Long lastUpdateUserMax;

  /**
   * 更新人 比较(eq)
   */
  private Long lastUpdateUserEq;
  /**
   * 更新人 比较(neq)
   */
  private Long lastUpdateUserNeq;
  /**
   * 更新人 比较(gt)
   */
  private Long lastUpdateUserGt;
  /**
   * 更新人 比较(gte)
   */
  private Long lastUpdateUserGte;
  /**
   * 更新人 比较(lt)
   */
  private Long lastUpdateUserLt;
  /**
   * 更新人 比较(lte)
   */
  private Long lastUpdateUserLte;
  /**
   * 更新人 比较(contains)
   */
  private Long lastUpdateUserContains;
  /**
   * 更新人 比较(notcontains)
   */
  private Long lastUpdateUserNotcontains;
  /**
   * 更新人 比较(startswith)
   */
  private Long lastUpdateUserStartswith;
  /**
   * 更新人 比较(endswith)
   */
  private Long lastUpdateUserEndswith;
  /**
   * 更新人 比较(isnull)
   */
  private Boolean lastUpdateUserIsnull;
  /**
   * 更新人 比较(isnotnull)
   */
  private Boolean lastUpdateUserIsnotnull;

  /**
   * 客户
   */
  private Long customer;

  /**
   * 客户 比较(eq)
   */
  private Long customerEq;
  /**
   * 客户 比较(neq)
   */
  private Long customerNeq;
  /**
   * 客户 比较(gt)
   */
  private Long customerGt;
  /**
   * 客户 比较(gte)
   */
  private Long customerGte;
  /**
   * 客户 比较(lt)
   */
  private Long customerLt;
  /**
   * 客户 比较(lte)
   */
  private Long customerLte;
  /**
   * 客户 比较(contains)
   */
  private Long customerContains;
  /**
   * 客户 比较(notcontains)
   */
  private Long customerNotcontains;
  /**
   * 客户 比较(startswith)
   */
  private Long customerStartswith;
  /**
   * 客户 比较(endswith)
   */
  private Long customerEndswith;
  /**
   * 客户 比较(isnull)
   */
  private Boolean customerIsnull;
  /**
   * 客户 比较(isnotnull)
   */
  private Boolean customerIsnotnull;
  /**
   * 客户的供应商简称 比较(eq)
   */
  private String customerSupplierNameEq;
  /**
   * 客户的供应商简称 比较(neq)
   */
  private String customerSupplierNameNeq;
  /**
   * 客户的供应商简称 比较(gt)
   */
  private String customerSupplierNameGt;
  /**
   * 客户的供应商简称 比较(gte)
   */
  private String customerSupplierNameGte;
  /**
   * 客户的供应商简称 比较(lt)
   */
  private String customerSupplierNameLt;
  /**
   * 客户的供应商简称 比较(lte)
   */
  private String customerSupplierNameLte;
  /**
   * 客户的供应商简称 比较(contains)
   */
  private String customerSupplierNameContains;
  /**
   * 客户的供应商简称 比较(notcontains)
   */
  private String customerSupplierNameNotcontains;
  /**
   * 客户的供应商简称 比较(startswith)
   */
  private String customerSupplierNameStartswith;
  /**
   * 客户的供应商简称 比较(endswith)
   */
  private String customerSupplierNameEndswith;
  /**
   * 客户的供应商简称 比较(isnull)
   */
  private Boolean customerSupplierNameIsnull;
  /**
   * 客户的供应商简称 比较(isnotnull)
   */
  private Boolean customerSupplierNameIsnotnull;

  /**
   * 客户(范围搜索)
   */
  private List<Long> customerInList;

  /**
   * 结算组织
   */
  private Long closeOrg;

  /**
   * 结算组织 比较(eq)
   */
  private Long closeOrgEq;
  /**
   * 结算组织 比较(neq)
   */
  private Long closeOrgNeq;
  /**
   * 结算组织 比较(gt)
   */
  private Long closeOrgGt;
  /**
   * 结算组织 比较(gte)
   */
  private Long closeOrgGte;
  /**
   * 结算组织 比较(lt)
   */
  private Long closeOrgLt;
  /**
   * 结算组织 比较(lte)
   */
  private Long closeOrgLte;
  /**
   * 结算组织 比较(contains)
   */
  private Long closeOrgContains;
  /**
   * 结算组织 比较(notcontains)
   */
  private Long closeOrgNotcontains;
  /**
   * 结算组织 比较(startswith)
   */
  private Long closeOrgStartswith;
  /**
   * 结算组织 比较(endswith)
   */
  private Long closeOrgEndswith;
  /**
   * 结算组织 比较(isnull)
   */
  private Boolean closeOrgIsnull;
  /**
   * 结算组织 比较(isnotnull)
   */
  private Boolean closeOrgIsnotnull;
  /**
   * 结算组织的部门名称 比较(eq)
   */
  private String closeOrgNameEq;
  /**
   * 结算组织的部门名称 比较(neq)
   */
  private String closeOrgNameNeq;
  /**
   * 结算组织的部门名称 比较(gt)
   */
  private String closeOrgNameGt;
  /**
   * 结算组织的部门名称 比较(gte)
   */
  private String closeOrgNameGte;
  /**
   * 结算组织的部门名称 比较(lt)
   */
  private String closeOrgNameLt;
  /**
   * 结算组织的部门名称 比较(lte)
   */
  private String closeOrgNameLte;
  /**
   * 结算组织的部门名称 比较(contains)
   */
  private String closeOrgNameContains;
  /**
   * 结算组织的部门名称 比较(notcontains)
   */
  private String closeOrgNameNotcontains;
  /**
   * 结算组织的部门名称 比较(startswith)
   */
  private String closeOrgNameStartswith;
  /**
   * 结算组织的部门名称 比较(endswith)
   */
  private String closeOrgNameEndswith;
  /**
   * 结算组织的部门名称 比较(isnull)
   */
  private Boolean closeOrgNameIsnull;
  /**
   * 结算组织的部门名称 比较(isnotnull)
   */
  private Boolean closeOrgNameIsnotnull;

  /**
   * 结算组织(范围搜索)
   */
  private List<Long> closeOrgInList;

  /**
   * 收款组织
   */
  private Long receiptOrg;

  /**
   * 收款组织 比较(eq)
   */
  private Long receiptOrgEq;
  /**
   * 收款组织 比较(neq)
   */
  private Long receiptOrgNeq;
  /**
   * 收款组织 比较(gt)
   */
  private Long receiptOrgGt;
  /**
   * 收款组织 比较(gte)
   */
  private Long receiptOrgGte;
  /**
   * 收款组织 比较(lt)
   */
  private Long receiptOrgLt;
  /**
   * 收款组织 比较(lte)
   */
  private Long receiptOrgLte;
  /**
   * 收款组织 比较(contains)
   */
  private Long receiptOrgContains;
  /**
   * 收款组织 比较(notcontains)
   */
  private Long receiptOrgNotcontains;
  /**
   * 收款组织 比较(startswith)
   */
  private Long receiptOrgStartswith;
  /**
   * 收款组织 比较(endswith)
   */
  private Long receiptOrgEndswith;
  /**
   * 收款组织 比较(isnull)
   */
  private Boolean receiptOrgIsnull;
  /**
   * 收款组织 比较(isnotnull)
   */
  private Boolean receiptOrgIsnotnull;
  /**
   * 收款组织的部门名称 比较(eq)
   */
  private String receiptOrgNameEq;
  /**
   * 收款组织的部门名称 比较(neq)
   */
  private String receiptOrgNameNeq;
  /**
   * 收款组织的部门名称 比较(gt)
   */
  private String receiptOrgNameGt;
  /**
   * 收款组织的部门名称 比较(gte)
   */
  private String receiptOrgNameGte;
  /**
   * 收款组织的部门名称 比较(lt)
   */
  private String receiptOrgNameLt;
  /**
   * 收款组织的部门名称 比较(lte)
   */
  private String receiptOrgNameLte;
  /**
   * 收款组织的部门名称 比较(contains)
   */
  private String receiptOrgNameContains;
  /**
   * 收款组织的部门名称 比较(notcontains)
   */
  private String receiptOrgNameNotcontains;
  /**
   * 收款组织的部门名称 比较(startswith)
   */
  private String receiptOrgNameStartswith;
  /**
   * 收款组织的部门名称 比较(endswith)
   */
  private String receiptOrgNameEndswith;
  /**
   * 收款组织的部门名称 比较(isnull)
   */
  private Boolean receiptOrgNameIsnull;
  /**
   * 收款组织的部门名称 比较(isnotnull)
   */
  private Boolean receiptOrgNameIsnotnull;

  /**
   * 收款组织(范围搜索)
   */
  private List<Long> receiptOrgInList;

  /**
   * 立账类型(模糊搜索)
   */
  private String accountType;

  /**
   * 立账类型 比较(eq)
   */
  private String accountTypeEq;
  /**
   * 立账类型 比较(neq)
   */
  private String accountTypeNeq;
  /**
   * 立账类型 比较(gt)
   */
  private String accountTypeGt;
  /**
   * 立账类型 比较(gte)
   */
  private String accountTypeGte;
  /**
   * 立账类型 比较(lt)
   */
  private String accountTypeLt;
  /**
   * 立账类型 比较(lte)
   */
  private String accountTypeLte;
  /**
   * 立账类型 比较(contains)
   */
  private String accountTypeContains;
  /**
   * 立账类型 比较(notcontains)
   */
  private String accountTypeNotcontains;
  /**
   * 立账类型 比较(startswith)
   */
  private String accountTypeStartswith;
  /**
   * 立账类型 比较(endswith)
   */
  private String accountTypeEndswith;
  /**
   * 立账类型 比较(isnull)
   */
  private Boolean accountTypeIsnull;
  /**
   * 立账类型 比较(isnotnull)
   */
  private Boolean accountTypeIsnotnull;

  /**
   * 立账类型(精确搜索)
   */
  private List<String> accountTypeInList;

  /**
   * 最早业务日期
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date businessDateStart;

  /**
   * 最晚业务日期
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date businessDateEnd;

  /**
   * 业务日期 比较(eq)
   */
  private Date businessDateEq;
  /**
   * 业务日期 比较(neq)
   */
  private Date businessDateNeq;
  /**
   * 业务日期 比较(gt)
   */
  private Date businessDateGt;
  /**
   * 业务日期 比较(gte)
   */
  private Date businessDateGte;
  /**
   * 业务日期 比较(lt)
   */
  private Date businessDateLt;
  /**
   * 业务日期 比较(lte)
   */
  private Date businessDateLte;
  /**
   * 业务日期 比较(contains)
   */
  private Date businessDateContains;
  /**
   * 业务日期 比较(notcontains)
   */
  private Date businessDateNotcontains;
  /**
   * 业务日期 比较(startswith)
   */
  private Date businessDateStartswith;
  /**
   * 业务日期 比较(endswith)
   */
  private Date businessDateEndswith;
  /**
   * 业务日期 比较(isnull)
   */
  private Boolean businessDateIsnull;
  /**
   * 业务日期 比较(isnotnull)
   */
  private Boolean businessDateIsnotnull;

  /**
   * 最早到期日
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date dueDateStart;

  /**
   * 最晚到期日
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date dueDateEnd;

  /**
   * 到期日 比较(eq)
   */
  private Date dueDateEq;
  /**
   * 到期日 比较(neq)
   */
  private Date dueDateNeq;
  /**
   * 到期日 比较(gt)
   */
  private Date dueDateGt;
  /**
   * 到期日 比较(gte)
   */
  private Date dueDateGte;
  /**
   * 到期日 比较(lt)
   */
  private Date dueDateLt;
  /**
   * 到期日 比较(lte)
   */
  private Date dueDateLte;
  /**
   * 到期日 比较(contains)
   */
  private Date dueDateContains;
  /**
   * 到期日 比较(notcontains)
   */
  private Date dueDateNotcontains;
  /**
   * 到期日 比较(startswith)
   */
  private Date dueDateStartswith;
  /**
   * 到期日 比较(endswith)
   */
  private Date dueDateEndswith;
  /**
   * 到期日 比较(isnull)
   */
  private Boolean dueDateIsnull;
  /**
   * 到期日 比较(isnotnull)
   */
  private Boolean dueDateIsnotnull;

  /**
   * 收款条件
   */
  private String receiptTerms;

  /**
   * 收款条件 比较(eq)
   */
  private String receiptTermsEq;
  /**
   * 收款条件 比较(neq)
   */
  private String receiptTermsNeq;
  /**
   * 收款条件 比较(gt)
   */
  private String receiptTermsGt;
  /**
   * 收款条件 比较(gte)
   */
  private String receiptTermsGte;
  /**
   * 收款条件 比较(lt)
   */
  private String receiptTermsLt;
  /**
   * 收款条件 比较(lte)
   */
  private String receiptTermsLte;
  /**
   * 收款条件 比较(contains)
   */
  private String receiptTermsContains;
  /**
   * 收款条件 比较(notcontains)
   */
  private String receiptTermsNotcontains;
  /**
   * 收款条件 比较(startswith)
   */
  private String receiptTermsStartswith;
  /**
   * 收款条件 比较(endswith)
   */
  private String receiptTermsEndswith;
  /**
   * 收款条件 比较(isnull)
   */
  private Boolean receiptTermsIsnull;
  /**
   * 收款条件 比较(isnotnull)
   */
  private Boolean receiptTermsIsnotnull;

  /**
   * 收款条件(精确搜索)
   */
  private List<String> receiptTermsInList;

  /**
   * 订货方
   */
  private Long orderer;

  /**
   * 订货方 比较(eq)
   */
  private Long ordererEq;
  /**
   * 订货方 比较(neq)
   */
  private Long ordererNeq;
  /**
   * 订货方 比较(gt)
   */
  private Long ordererGt;
  /**
   * 订货方 比较(gte)
   */
  private Long ordererGte;
  /**
   * 订货方 比较(lt)
   */
  private Long ordererLt;
  /**
   * 订货方 比较(lte)
   */
  private Long ordererLte;
  /**
   * 订货方 比较(contains)
   */
  private Long ordererContains;
  /**
   * 订货方 比较(notcontains)
   */
  private Long ordererNotcontains;
  /**
   * 订货方 比较(startswith)
   */
  private Long ordererStartswith;
  /**
   * 订货方 比较(endswith)
   */
  private Long ordererEndswith;
  /**
   * 订货方 比较(isnull)
   */
  private Boolean ordererIsnull;
  /**
   * 订货方 比较(isnotnull)
   */
  private Boolean ordererIsnotnull;
  /**
   * 订货方的供应商简称 比较(eq)
   */
  private String ordererSupplierNameEq;
  /**
   * 订货方的供应商简称 比较(neq)
   */
  private String ordererSupplierNameNeq;
  /**
   * 订货方的供应商简称 比较(gt)
   */
  private String ordererSupplierNameGt;
  /**
   * 订货方的供应商简称 比较(gte)
   */
  private String ordererSupplierNameGte;
  /**
   * 订货方的供应商简称 比较(lt)
   */
  private String ordererSupplierNameLt;
  /**
   * 订货方的供应商简称 比较(lte)
   */
  private String ordererSupplierNameLte;
  /**
   * 订货方的供应商简称 比较(contains)
   */
  private String ordererSupplierNameContains;
  /**
   * 订货方的供应商简称 比较(notcontains)
   */
  private String ordererSupplierNameNotcontains;
  /**
   * 订货方的供应商简称 比较(startswith)
   */
  private String ordererSupplierNameStartswith;
  /**
   * 订货方的供应商简称 比较(endswith)
   */
  private String ordererSupplierNameEndswith;
  /**
   * 订货方的供应商简称 比较(isnull)
   */
  private Boolean ordererSupplierNameIsnull;
  /**
   * 订货方的供应商简称 比较(isnotnull)
   */
  private Boolean ordererSupplierNameIsnotnull;

  /**
   * 订货方(范围搜索)
   */
  private List<Long> ordererInList;

  /**
   * 收货方
   */
  private Long consignee;

  /**
   * 收货方 比较(eq)
   */
  private Long consigneeEq;
  /**
   * 收货方 比较(neq)
   */
  private Long consigneeNeq;
  /**
   * 收货方 比较(gt)
   */
  private Long consigneeGt;
  /**
   * 收货方 比较(gte)
   */
  private Long consigneeGte;
  /**
   * 收货方 比较(lt)
   */
  private Long consigneeLt;
  /**
   * 收货方 比较(lte)
   */
  private Long consigneeLte;
  /**
   * 收货方 比较(contains)
   */
  private Long consigneeContains;
  /**
   * 收货方 比较(notcontains)
   */
  private Long consigneeNotcontains;
  /**
   * 收货方 比较(startswith)
   */
  private Long consigneeStartswith;
  /**
   * 收货方 比较(endswith)
   */
  private Long consigneeEndswith;
  /**
   * 收货方 比较(isnull)
   */
  private Boolean consigneeIsnull;
  /**
   * 收货方 比较(isnotnull)
   */
  private Boolean consigneeIsnotnull;
  /**
   * 收货方的供应商简称 比较(eq)
   */
  private String consigneeSupplierNameEq;
  /**
   * 收货方的供应商简称 比较(neq)
   */
  private String consigneeSupplierNameNeq;
  /**
   * 收货方的供应商简称 比较(gt)
   */
  private String consigneeSupplierNameGt;
  /**
   * 收货方的供应商简称 比较(gte)
   */
  private String consigneeSupplierNameGte;
  /**
   * 收货方的供应商简称 比较(lt)
   */
  private String consigneeSupplierNameLt;
  /**
   * 收货方的供应商简称 比较(lte)
   */
  private String consigneeSupplierNameLte;
  /**
   * 收货方的供应商简称 比较(contains)
   */
  private String consigneeSupplierNameContains;
  /**
   * 收货方的供应商简称 比较(notcontains)
   */
  private String consigneeSupplierNameNotcontains;
  /**
   * 收货方的供应商简称 比较(startswith)
   */
  private String consigneeSupplierNameStartswith;
  /**
   * 收货方的供应商简称 比较(endswith)
   */
  private String consigneeSupplierNameEndswith;
  /**
   * 收货方的供应商简称 比较(isnull)
   */
  private Boolean consigneeSupplierNameIsnull;
  /**
   * 收货方的供应商简称 比较(isnotnull)
   */
  private Boolean consigneeSupplierNameIsnotnull;

  /**
   * 收货方(范围搜索)
   */
  private List<Long> consigneeInList;

  /**
   * 付款方
   */
  private Long payer;

  /**
   * 付款方 比较(eq)
   */
  private Long payerEq;
  /**
   * 付款方 比较(neq)
   */
  private Long payerNeq;
  /**
   * 付款方 比较(gt)
   */
  private Long payerGt;
  /**
   * 付款方 比较(gte)
   */
  private Long payerGte;
  /**
   * 付款方 比较(lt)
   */
  private Long payerLt;
  /**
   * 付款方 比较(lte)
   */
  private Long payerLte;
  /**
   * 付款方 比较(contains)
   */
  private Long payerContains;
  /**
   * 付款方 比较(notcontains)
   */
  private Long payerNotcontains;
  /**
   * 付款方 比较(startswith)
   */
  private Long payerStartswith;
  /**
   * 付款方 比较(endswith)
   */
  private Long payerEndswith;
  /**
   * 付款方 比较(isnull)
   */
  private Boolean payerIsnull;
  /**
   * 付款方 比较(isnotnull)
   */
  private Boolean payerIsnotnull;
  /**
   * 付款方的供应商简称 比较(eq)
   */
  private String payerSupplierNameEq;
  /**
   * 付款方的供应商简称 比较(neq)
   */
  private String payerSupplierNameNeq;
  /**
   * 付款方的供应商简称 比较(gt)
   */
  private String payerSupplierNameGt;
  /**
   * 付款方的供应商简称 比较(gte)
   */
  private String payerSupplierNameGte;
  /**
   * 付款方的供应商简称 比较(lt)
   */
  private String payerSupplierNameLt;
  /**
   * 付款方的供应商简称 比较(lte)
   */
  private String payerSupplierNameLte;
  /**
   * 付款方的供应商简称 比较(contains)
   */
  private String payerSupplierNameContains;
  /**
   * 付款方的供应商简称 比较(notcontains)
   */
  private String payerSupplierNameNotcontains;
  /**
   * 付款方的供应商简称 比较(startswith)
   */
  private String payerSupplierNameStartswith;
  /**
   * 付款方的供应商简称 比较(endswith)
   */
  private String payerSupplierNameEndswith;
  /**
   * 付款方的供应商简称 比较(isnull)
   */
  private Boolean payerSupplierNameIsnull;
  /**
   * 付款方的供应商简称 比较(isnotnull)
   */
  private Boolean payerSupplierNameIsnotnull;

  /**
   * 付款方(范围搜索)
   */
  private List<Long> payerInList;

  /**
   * 备注(模糊搜索)
   */
  private String remark;

  /**
   * 备注 比较(eq)
   */
  private String remarkEq;
  /**
   * 备注 比较(neq)
   */
  private String remarkNeq;
  /**
   * 备注 比较(gt)
   */
  private String remarkGt;
  /**
   * 备注 比较(gte)
   */
  private String remarkGte;
  /**
   * 备注 比较(lt)
   */
  private String remarkLt;
  /**
   * 备注 比较(lte)
   */
  private String remarkLte;
  /**
   * 备注 比较(contains)
   */
  private String remarkContains;
  /**
   * 备注 比较(notcontains)
   */
  private String remarkNotcontains;
  /**
   * 备注 比较(startswith)
   */
  private String remarkStartswith;
  /**
   * 备注 比较(endswith)
   */
  private String remarkEndswith;
  /**
   * 备注 比较(isnull)
   */
  private Boolean remarkIsnull;
  /**
   * 备注 比较(isnotnull)
   */
  private Boolean remarkIsnotnull;

  /**
   * 备注(精确搜索)
   */
  private List<String> remarkInList;

  /**
   * 产品类型
   */
  private String productType;

  /**
   * 产品类型 比较(eq)
   */
  private String productTypeEq;
  /**
   * 产品类型 比较(neq)
   */
  private String productTypeNeq;
  /**
   * 产品类型 比较(gt)
   */
  private String productTypeGt;
  /**
   * 产品类型 比较(gte)
   */
  private String productTypeGte;
  /**
   * 产品类型 比较(lt)
   */
  private String productTypeLt;
  /**
   * 产品类型 比较(lte)
   */
  private String productTypeLte;
  /**
   * 产品类型 比较(contains)
   */
  private String productTypeContains;
  /**
   * 产品类型 比较(notcontains)
   */
  private String productTypeNotcontains;
  /**
   * 产品类型 比较(startswith)
   */
  private String productTypeStartswith;
  /**
   * 产品类型 比较(endswith)
   */
  private String productTypeEndswith;
  /**
   * 产品类型 比较(isnull)
   */
  private Boolean productTypeIsnull;
  /**
   * 产品类型 比较(isnotnull)
   */
  private Boolean productTypeIsnotnull;

  /**
   * 产品类型(精确搜索)
   */
  private List<String> productTypeInList;

  /**
   * 状态
   */
  private String status;

  /**
   * 状态 比较(eq)
   */
  private String statusEq;
  /**
   * 状态 比较(neq)
   */
  private String statusNeq;
  /**
   * 状态 比较(gt)
   */
  private String statusGt;
  /**
   * 状态 比较(gte)
   */
  private String statusGte;
  /**
   * 状态 比较(lt)
   */
  private String statusLt;
  /**
   * 状态 比较(lte)
   */
  private String statusLte;
  /**
   * 状态 比较(contains)
   */
  private String statusContains;
  /**
   * 状态 比较(notcontains)
   */
  private String statusNotcontains;
  /**
   * 状态 比较(startswith)
   */
  private String statusStartswith;
  /**
   * 状态 比较(endswith)
   */
  private String statusEndswith;
  /**
   * 状态 比较(isnull)
   */
  private Boolean statusIsnull;
  /**
   * 状态 比较(isnotnull)
   */
  private Boolean statusIsnotnull;

  /**
   * 状态(精确搜索)
   */
  private List<String> statusInList;

  /**
   * 推送状态
   */
  private String pushStatus;

  /**
   * 推送状态 比较(eq)
   */
  private String pushStatusEq;
  /**
   * 推送状态 比较(neq)
   */
  private String pushStatusNeq;
  /**
   * 推送状态 比较(gt)
   */
  private String pushStatusGt;
  /**
   * 推送状态 比较(gte)
   */
  private String pushStatusGte;
  /**
   * 推送状态 比较(lt)
   */
  private String pushStatusLt;
  /**
   * 推送状态 比较(lte)
   */
  private String pushStatusLte;
  /**
   * 推送状态 比较(contains)
   */
  private String pushStatusContains;
  /**
   * 推送状态 比较(notcontains)
   */
  private String pushStatusNotcontains;
  /**
   * 推送状态 比较(startswith)
   */
  private String pushStatusStartswith;
  /**
   * 推送状态 比较(endswith)
   */
  private String pushStatusEndswith;
  /**
   * 推送状态 比较(isnull)
   */
  private Boolean pushStatusIsnull;
  /**
   * 推送状态 比较(isnotnull)
   */
  private Boolean pushStatusIsnotnull;

  /**
   * 推送状态(精确搜索)
   */
  private List<String> pushStatusInList;

  /**
   * 推送信息(模糊搜索)
   */
  private String resultInfo;

  /**
   * 推送信息 比较(eq)
   */
  private String resultInfoEq;
  /**
   * 推送信息 比较(neq)
   */
  private String resultInfoNeq;
  /**
   * 推送信息 比较(gt)
   */
  private String resultInfoGt;
  /**
   * 推送信息 比较(gte)
   */
  private String resultInfoGte;
  /**
   * 推送信息 比较(lt)
   */
  private String resultInfoLt;
  /**
   * 推送信息 比较(lte)
   */
  private String resultInfoLte;
  /**
   * 推送信息 比较(contains)
   */
  private String resultInfoContains;
  /**
   * 推送信息 比较(notcontains)
   */
  private String resultInfoNotcontains;
  /**
   * 推送信息 比较(startswith)
   */
  private String resultInfoStartswith;
  /**
   * 推送信息 比较(endswith)
   */
  private String resultInfoEndswith;
  /**
   * 推送信息 比较(isnull)
   */
  private Boolean resultInfoIsnull;
  /**
   * 推送信息 比较(isnotnull)
   */
  private Boolean resultInfoIsnotnull;

  /**
   * 推送信息(精确搜索)
   */
  private List<String> resultInfoInList;

  /**
   * 制单人
   */
  private Long preparedBy;

  /**
   * 制单人 比较(eq)
   */
  private Long preparedByEq;
  /**
   * 制单人 比较(neq)
   */
  private Long preparedByNeq;
  /**
   * 制单人 比较(gt)
   */
  private Long preparedByGt;
  /**
   * 制单人 比较(gte)
   */
  private Long preparedByGte;
  /**
   * 制单人 比较(lt)
   */
  private Long preparedByLt;
  /**
   * 制单人 比较(lte)
   */
  private Long preparedByLte;
  /**
   * 制单人 比较(contains)
   */
  private Long preparedByContains;
  /**
   * 制单人 比较(notcontains)
   */
  private Long preparedByNotcontains;
  /**
   * 制单人 比较(startswith)
   */
  private Long preparedByStartswith;
  /**
   * 制单人 比较(endswith)
   */
  private Long preparedByEndswith;
  /**
   * 制单人 比较(isnull)
   */
  private Boolean preparedByIsnull;
  /**
   * 制单人 比较(isnotnull)
   */
  private Boolean preparedByIsnotnull;
  /**
   * 制单人的显示用户名 比较(eq)
   */
  private String preparedByNameEq;
  /**
   * 制单人的显示用户名 比较(neq)
   */
  private String preparedByNameNeq;
  /**
   * 制单人的显示用户名 比较(gt)
   */
  private String preparedByNameGt;
  /**
   * 制单人的显示用户名 比较(gte)
   */
  private String preparedByNameGte;
  /**
   * 制单人的显示用户名 比较(lt)
   */
  private String preparedByNameLt;
  /**
   * 制单人的显示用户名 比较(lte)
   */
  private String preparedByNameLte;
  /**
   * 制单人的显示用户名 比较(contains)
   */
  private String preparedByNameContains;
  /**
   * 制单人的显示用户名 比较(notcontains)
   */
  private String preparedByNameNotcontains;
  /**
   * 制单人的显示用户名 比较(startswith)
   */
  private String preparedByNameStartswith;
  /**
   * 制单人的显示用户名 比较(endswith)
   */
  private String preparedByNameEndswith;
  /**
   * 制单人的显示用户名 比较(isnull)
   */
  private Boolean preparedByNameIsnull;
  /**
   * 制单人的显示用户名 比较(isnotnull)
   */
  private Boolean preparedByNameIsnotnull;

  /**
   * 制单人(范围搜索)
   */
  private List<Long> preparedByInList;

  /**
   * 审核人
   */
  private Long verifier;

  /**
   * 审核人 比较(eq)
   */
  private Long verifierEq;
  /**
   * 审核人 比较(neq)
   */
  private Long verifierNeq;
  /**
   * 审核人 比较(gt)
   */
  private Long verifierGt;
  /**
   * 审核人 比较(gte)
   */
  private Long verifierGte;
  /**
   * 审核人 比较(lt)
   */
  private Long verifierLt;
  /**
   * 审核人 比较(lte)
   */
  private Long verifierLte;
  /**
   * 审核人 比较(contains)
   */
  private Long verifierContains;
  /**
   * 审核人 比较(notcontains)
   */
  private Long verifierNotcontains;
  /**
   * 审核人 比较(startswith)
   */
  private Long verifierStartswith;
  /**
   * 审核人 比较(endswith)
   */
  private Long verifierEndswith;
  /**
   * 审核人 比较(isnull)
   */
  private Boolean verifierIsnull;
  /**
   * 审核人 比较(isnotnull)
   */
  private Boolean verifierIsnotnull;
  /**
   * 审核人的显示用户名 比较(eq)
   */
  private String verifierNameEq;
  /**
   * 审核人的显示用户名 比较(neq)
   */
  private String verifierNameNeq;
  /**
   * 审核人的显示用户名 比较(gt)
   */
  private String verifierNameGt;
  /**
   * 审核人的显示用户名 比较(gte)
   */
  private String verifierNameGte;
  /**
   * 审核人的显示用户名 比较(lt)
   */
  private String verifierNameLt;
  /**
   * 审核人的显示用户名 比较(lte)
   */
  private String verifierNameLte;
  /**
   * 审核人的显示用户名 比较(contains)
   */
  private String verifierNameContains;
  /**
   * 审核人的显示用户名 比较(notcontains)
   */
  private String verifierNameNotcontains;
  /**
   * 审核人的显示用户名 比较(startswith)
   */
  private String verifierNameStartswith;
  /**
   * 审核人的显示用户名 比较(endswith)
   */
  private String verifierNameEndswith;
  /**
   * 审核人的显示用户名 比较(isnull)
   */
  private Boolean verifierNameIsnull;
  /**
   * 审核人的显示用户名 比较(isnotnull)
   */
  private Boolean verifierNameIsnotnull;

  /**
   * 审核人(范围搜索)
   */
  private List<Long> verifierInList;

  /**
   * 采购单号(模糊搜索)
   */
  private String purchaseOrder;

  /**
   * 采购单号 比较(eq)
   */
  private String purchaseOrderEq;
  /**
   * 采购单号 比较(neq)
   */
  private String purchaseOrderNeq;
  /**
   * 采购单号 比较(gt)
   */
  private String purchaseOrderGt;
  /**
   * 采购单号 比较(gte)
   */
  private String purchaseOrderGte;
  /**
   * 采购单号 比较(lt)
   */
  private String purchaseOrderLt;
  /**
   * 采购单号 比较(lte)
   */
  private String purchaseOrderLte;
  /**
   * 采购单号 比较(contains)
   */
  private String purchaseOrderContains;
  /**
   * 采购单号 比较(notcontains)
   */
  private String purchaseOrderNotcontains;
  /**
   * 采购单号 比较(startswith)
   */
  private String purchaseOrderStartswith;
  /**
   * 采购单号 比较(endswith)
   */
  private String purchaseOrderEndswith;
  /**
   * 采购单号 比较(isnull)
   */
  private Boolean purchaseOrderIsnull;
  /**
   * 采购单号 比较(isnotnull)
   */
  private Boolean purchaseOrderIsnotnull;

  /**
   * 采购单号(精确搜索)
   */
  private List<String> purchaseOrderInList;

  /**
   * 出库单号(模糊搜索)
   */
  private String warehouseSn;

  /**
   * 出库单号 比较(eq)
   */
  private String warehouseSnEq;
  /**
   * 出库单号 比较(neq)
   */
  private String warehouseSnNeq;
  /**
   * 出库单号 比较(gt)
   */
  private String warehouseSnGt;
  /**
   * 出库单号 比较(gte)
   */
  private String warehouseSnGte;
  /**
   * 出库单号 比较(lt)
   */
  private String warehouseSnLt;
  /**
   * 出库单号 比较(lte)
   */
  private String warehouseSnLte;
  /**
   * 出库单号 比较(contains)
   */
  private String warehouseSnContains;
  /**
   * 出库单号 比较(notcontains)
   */
  private String warehouseSnNotcontains;
  /**
   * 出库单号 比较(startswith)
   */
  private String warehouseSnStartswith;
  /**
   * 出库单号 比较(endswith)
   */
  private String warehouseSnEndswith;
  /**
   * 出库单号 比较(isnull)
   */
  private Boolean warehouseSnIsnull;
  /**
   * 出库单号 比较(isnotnull)
   */
  private Boolean warehouseSnIsnotnull;

  /**
   * 出库单号(精确搜索)
   */
  private List<String> warehouseSnInList;

  /**
   * 表单名称
   */
  private String formName;

  /**
   * 工作流状态
   */
  private Integer wfStatus;
}
